package com.gl.util;

import javax.imageio.ImageIO;
import org.apache.log4j.Logger;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Calendar;
import java.util.Collection;
import java.util.List;
import java.util.Map;

public class CommonUtil {
    protected static Logger logger = Logger.getLogger(com.gl.util.CommonUtil.class);

    /**
     * 向日志中输出错误信息
     * @param e
     */
    public static void error(Exception e) {
        logger.error("error", e);
    }

    /**
     * 向日志中输出错误信息
     * @param str
     * @param e
     */
    public static void error(String str, Exception e) {
        logger.error(str, e);
    }

    /**
     * 向日志中输出info级别的信息
     * @param content
     */
    public static void info(Object content) {
        logger.info("info: " + content);
    }

    /**
     * 向日志中输出错误信息
     * @param content	包含错误信息的对象，会输出其toString方法的返回结果
     */
    public static void error(Object content) {
        logger.error("error: " + content);
    }

    /**
     * 向日志中输出调试信息
     * @param content	调试信息字符串
     */
    public static void debug(String content) {
        logger.debug("debug: " + content);
    }

    /**
     * 向日志中输出调试信息
     * @param contentObj	包含调试信息的对象，会输出其toString方法的返回结果
     */
    public static void debug(Object contentObj) {
        if (contentObj == null) {
            debug("debug: " + contentObj);
        } else {
            debug("debug: " + contentObj.toString());
        }
    }

    /**
     * 异常处理方法：
     * 1、向日志中输出异常信息
     * 2、打印错误堆栈
     * @param e 异常对象
     */
    public static void showException(Exception e) {
        logger.error("error: ", e);
        e.printStackTrace();
    }

    /**
     * 人为制造一个异常并向日志中输出堆栈信息，用于定位bug
     */
    protected static void printStack() {
        StackTraceElement stacks[] = (new Throwable()).getStackTrace();
        for (int i = 0; i < stacks.length; i++) {
            StackTraceElement stack = stacks[i];
            String cname = stack.getClassName();
            int lineNumber = stack.getLineNumber();
            logger.error("[Stack Info] " + cname + ", line:[" + lineNumber + "]");
        }
    }

    /**
     * 内容前后带星星的输出
     * @param content
     * @param starCount
     */
    public static void debugWithStar(String content, int starCount) {
        StringBuffer sb = new StringBuffer(" ");

        for (int i = 0; i < starCount; i++) {
            sb.append("*");
        }
        sb.append(" ");
        String stars = sb.toString();
        logger.debug(stars + content + stars);
    }

    /**
     * 内容前带10个星号的输出
     * @param content
     */
    public static void debugWithStar(String content) {
        String stars = " ********** ";
        logger.debug(stars + content);
    }

    /**
     * 字符串转整型数字
     * @param str
     * @return
     */
    public static int stringToInt(Object str, int defaultValue) {
        if (str == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(str.toString());
        } catch (Exception e) {
            return defaultValue;
        }
    }
    /**
     * 字符串转整型数字
     * @param str
     * @return
     */
    public static int stringToInt(Object str) {
        return stringToInt(str, 0);
    }
    
    /**
     * 获取对象长度
     * @Title: size  
     * @Discription:   
     * @param obj
     * @return 
     * @return int  
     * 
     * 修改历史
     * --------------------------------------- 
     * lvbo 2013-10-23 上午11:53:22
     */
    public static int size(Object obj) {
    	if(obj == null) {
    		return 0;
    	} else if(obj instanceof Collection) {
    		return ((Collection)obj).size();
    	} else if(obj instanceof Map) {
    		return ((Map)obj).size();
    	} else if(obj.getClass().isArray()) {
    		return ((Object[])obj).length;
    	} else if(obj instanceof String) {
    		return ((String)obj).length();
    	} else {
    		return 0;
    	}
    }

    /**
     * 判断对象是否为空
     * @Title: empty  
     * @Discription:  判断是否为null 或String Collection、Map、数组是否为空 ， 
     * 					除以上类型外，都返回true，及认为为空
     * @param obj
     * @return 
     * @return boolean  
     * 
     * 修改历史
     * --------------------------------------- 
     * lvbo 2013-10-15 上午10:36:34
     */
    @SuppressWarnings("unchecked")
	public static boolean empty(Object obj) {
    	if(obj == null) {
    		return true;
    	} else if(obj instanceof String) {
    		String str = (String)obj;
    		return "".equals(str);
    	} else if(obj instanceof Collection) {
    		Collection collection = (Collection) obj;
    		return collection.size() == 0;
    	} else if(obj instanceof Map) {
    		Map map = (Map) obj;
    		return map.isEmpty();
    	} else if(obj.getClass().isArray()) {
    		Object[] arrayObjects = (Object[]) obj;
    		return arrayObjects.length == 0;
    	}else {
    		return true;
    	}
    }
    
    /**
     * 判断是否非空
     * @Title: notEmpty  
     * @Discription: 取空的逆  
     * @param obj
     * @return 
     * @return boolean  
     * 
     * 修改历史
     * --------------------------------------- 
     * lvbo 2013-10-15 上午10:37:21
     */
    public static boolean notEmpty(Object obj) {
    	return !empty(obj);
    }
    
    
    /**
     * 判断一个字符串是否为空或是否是空字符串，如果是，则返回true
     * @param str
     * @return
     */
    public static boolean isBlank(String str) {
        return str == null || str.trim().equals("");
    }

    /**
     * 判断一个字符串是否为不为空(即不为null且不是空字符串),如果不为空，则返回true
     * @param str
     * @return
     */
    public static boolean isNotBlank(String str) {
        return str != null && !str.trim().equals("");
    }

    /**
     * 判断一个List是否不为空(即不为null且长度不为0),如果不为空，则返回true
     * @param list
     * @return
     */
    public static boolean isNotEmpty(List list) {
        return !isEmpty(list);
    }

    /**
     * 判断一个List是否为空(即为null或长度为0),如果为空，则返回true
     * @param list
     * @return
     */
    public static boolean isEmpty(List list) {
        return list == null || list.isEmpty();
    }
    
    /**
     * 获取长度
     * @Title: length
     * @Description: List、Set、Map、String 为null返回0， 非以上类型时返回 -1
     * @param object
     * @return
     * -------------------------------------------
     * 2013-9-2 lvbo v1.0.0 create
     */
    public static long length(Object object) {
    	if(object == null) {
    		return 0;
    	}
    	
    	if(object instanceof Collection) {
    		Collection collection = (Collection)object;
    		return collection.size();
    	} else if(object instanceof Map) {
    		Map map = (Map)object;
    		return map.size();
    	} else if(object instanceof String) {
    		String string = (String) object;
    		return string.length();
    	} else {
    		return -1;
    	}
    }

    /**
     * 获取一个字符串对象的非空表示，即如果该对象为空，则返回空字符串，否则返回其本身
     * @param str
     * @return
     */
    protected static String getString(String str) {
        if (str == null) {
            return "";
        } else {
            return str;
        }
    }

    /**
     * 从List中获得id字符串，处理后，每个id均用单引号括起来，且各个id以逗号分隔
     * @param  ids
     * @return String ids
     */
    protected static String getIdString(List ids) {
        int len = ids.size();
        StringBuffer id = new StringBuffer();
        for(int i = 0; i < len; i++) {
            id.append("'");
            id.append((String) ids.get(i));
            id.append("',");
        }
        if(id.length() != 0) {
            id.deleteCharAt(id.length() - 1);
        }
        return id.toString();
    }

    /**
     * 从List中获得数字字符串，处理后，每个数字以逗号分隔
     * @param  numbers
     * @return String ids
     */
    protected static String getNumbersString(List numbers) {
        int len = numbers.size();
        StringBuffer ret = new StringBuffer();
        for(int i = 0; i < len; i++) {
            ret.append(numbers.get(i));
            ret.append(",");
        }
        if(ret.length() != 0) {
            ret.deleteCharAt(ret.length() - 1);
        }
        return ret.toString();
    }
  
    
    public  static String getPostFix(String fileName) {
        if (fileName == null || fileName.equals(""))
            return "";
        String[] names = fileName.split("\\.");
        return names[names.length-1];
    }
    public static String dealRelativePath(String path) {
        if (path == null)
            return "";
        return path + "\\";
    }
    public static String getHttpRelativePath(String path) {
        if (path == null)
               return "";
        return path.replaceAll("\\\\", "/") + "/";
    }
}